package cn.sunshine.ymcc.service.impl;

import cn.sunshine.ymcc.constants.RedisConstants;
import cn.sunshine.ymcc.domain.CourseType;
import cn.sunshine.ymcc.dto.CourseTypeTreeDTO;
import cn.sunshine.ymcc.dto.CrumbsDto;
import cn.sunshine.ymcc.mapper.CourseTypeMapper;
import cn.sunshine.ymcc.result.JSONResult;
import cn.sunshine.ymcc.service.ICourseTypeService;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author Mr.Jiang
 * @since 2022-08-08
 */
@Service
@Slf4j
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private CourseTypeMapper courseTypeMapper;
    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    @Cacheable(cacheNames= RedisConstants.KEY_COURSE_TYPE_TREE,key="'trees'")
    public List getTreeData() {
        return treeQuery();
        /*String treeKey = "treeKey";
        // 1.先去Redis中器寻找是不是存在
        // redisTemplate.delete(treeKey);
        Object treeTemplate = redisTemplate.opsForValue().get(treeKey);
        log.info("我是来Redis中拿课程树的");
        if (treeTemplate != null) {
            return JSONResult.success(treeTemplate);
        } else {
            // 2.如果在Redis中找不到课程树就去数据库查询然后保存到Redis中
            List<CourseTypeTreeDTO> courseTypeTreeDTOS = treeQuery();
            log.info("我是来查询课程树的");
            redisTemplate.opsForValue().set(treeKey, courseTypeTreeDTOS);
            return JSONResult.success(courseTypeTreeDTOS);
        }*/
    }

    @Override
    public JSONResult getCrumbs(Long courseTypeId) {
        CourseType courseType = courseTypeMapper.selectById(courseTypeId);
        String[] split = courseType.getPath().split("\\.");
        ArrayList<CrumbsDto> resultList = new ArrayList<>();
        for (String string:split) {
            CrumbsDto crumbsDto = new CrumbsDto();
            Long aLong = Long.valueOf(string);
            CourseType courseType1 = courseTypeMapper.selectById(aLong);
            Wrapper<CourseType> wrapper = new EntityWrapper<>();
            wrapper.eq("pid",courseType1.getPid());
            List<CourseType> courseTypes = courseTypeMapper.selectList(wrapper);
            crumbsDto.setOwnerProductType(courseType1);
            crumbsDto.setOtherProductTypes(courseTypes);
            resultList.add(crumbsDto);
        }
        return JSONResult.success(resultList);
    }

    /*
     * @Title: updateById
     * @Description: 重写方法，实时更新Redis数据，
     * @Author: Mr.Jiang
     * @Version: 1.0
     * @Date:  2022/8/11 10:02
     * @Parameters: [entity]
     * @Return boolean
     */
    @Override
    @CacheEvict(cacheNames= RedisConstants.KEY_COURSE_TYPE_TREE,key="'trees'")
    public boolean updateById(CourseType entity) {

      /*  boolean success = super.updateById(entity);
        if (success) {
            redisTemplate.delete("treeKey");
        }
        return success;*/
        return super.updateById(entity);
    }

    @Override
    @CacheEvict(cacheNames= RedisConstants.KEY_COURSE_TYPE_TREE,key="'trees'")
    public boolean deleteById(Serializable id) {
      /*  boolean success = super.deleteById(id);
        if (success) {
            redisTemplate.delete("treeKey");
        }
        return success;*/
        return super.deleteById(id);
    }

    @Override
    @CacheEvict(cacheNames= RedisConstants.KEY_COURSE_TYPE_TREE,key="'trees'")
    public boolean insert(CourseType entity) {
        /*boolean insert = super.insert(entity);
        if (insert) {
            redisTemplate.delete("treeKey");
        }
        return insert;*/
        return super.insert(entity);
    }

    public List<CourseTypeTreeDTO> treeQuery() {

        //到数据库中查询所有的数据
        List<CourseType> courseTypes = courseTypeMapper.selectList(null);

        //用来更方便得找父类  key放id   value  放dto对象
        HashMap<Long, CourseTypeTreeDTO> allDtoMap = new HashMap<>();

        //用来放所有CourseType转成CourseTypeTreeDTO的集合
        List<CourseTypeTreeDTO> allDtoList = new ArrayList<>();

        //返回的数据的集合(就是每个顶级)
        List<CourseTypeTreeDTO> resultList = new ArrayList<>();

        //把CourseType  转换为CourseTypeTreeDTO
        //放到allDtoList  和  allDtoMap
        for (CourseType courseType : courseTypes) {

            //把CourseType  转换为CourseTypeTreeDTO
            CourseTypeTreeDTO courseTypeTreeDTO = new CourseTypeTreeDTO();
            BeanUtils.copyProperties(courseType, courseTypeTreeDTO);
            courseTypeTreeDTO.setChildren(new ArrayList<>());
            courseTypeTreeDTO.setLabel(courseTypeTreeDTO.getName());
            allDtoMap.put(courseTypeTreeDTO.getId(), courseTypeTreeDTO);
            allDtoList.add(courseTypeTreeDTO);
            /*

             * */

        }

        //循环所有的数据  通过pid  到map中找到父
        for (CourseTypeTreeDTO dto : allDtoList) {
            //找到父
            Long pid = dto.getPid();
            CourseTypeTreeDTO courseTypeTreeDTO = allDtoMap.get(pid);


            //如果是null  那么说明是顶级父类
            if (courseTypeTreeDTO == null) {
                //顶级父类放到resultList
                resultList.add(dto);
                continue;
            }
            //拿到装到父类中去
            courseTypeTreeDTO.getChildren().add(dto);
        }
        return resultList;
    }

    //@Override
    //public JSONResult<List<CourseTypeTreeDTO>> getTreeData() {
    //    //返回的  首先要有label 和children  所以写一个类  继承CourseType
    //
    //    /*
    //    1.先把所有的数据都查出来
    //    2.遍历查出来的数据-->找一级的(pid为null或者为0)-->
    //        放在一个list里面(这个list就是最后返回的list)
    //    3.还要遍历所有的  找到他爸爸  set到爸爸的children集合中
    //     */
    //
    //    //查出所有的数据
    //    List<CourseType> courseTypes = courseTypeMapper.selectList(null);
    //    List<CourseTypeTreeDTO> resultList = new ArrayList<>();
    //    List<CourseTypeTreeDTO> allDtoList = new ArrayList<>();
    //
    //    for (CourseType courseType : courseTypes) {
    //        CourseTypeTreeDTO courseTypeTreeDTO = new CourseTypeTreeDTO();
    //        BeanUtils.copyProperties(courseType, courseTypeTreeDTO);
    //        courseTypeTreeDTO.setChildren(new ArrayList<>());
    //
    //        courseTypeTreeDTO.setLabel(courseTypeTreeDTO.getName());
    //        allDtoList.add(courseTypeTreeDTO);
    //    }
    //    //遍历查出来的数据-->找一级的(pid为null或者为0)
    //    for (CourseTypeTreeDTO courseType : allDtoList) {
    //        for (CourseTypeTreeDTO type : allDtoList) {
    //            //如果相等 那就找到爸爸了
    //            if (type.getPid().equals(courseType.getId())) {
    //                courseType.getChildren().add(type);
    //            }
    //        }
    //    }
    //    for (CourseTypeTreeDTO dto : allDtoList) {
    //        if (dto.getPid()==null||dto.getPid()==0) {
    //            resultList.add(dto);
    //        }
    //    }
    //
    //    return JSONResult.success(resultList);
    //}

}
